/*
 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package javax.swing.text;

import sun.reflect.misc.ReflectUtil;
import sun.swing.SwingUtilities2;

import java.io.Serializable;
import java.lang.reflect.*;
import java.text.ParseException;
import javax.swing.*;
import javax.swing.text.*;

/**
 * <code>DefaultFormatter</code> formats arbitrary objects. Formatting is done
 * by invoking the <code>toString</code> method. In order to convert the
 * value back to a String, your class must provide a constructor that
 * takes a String argument. If no single argument constructor that takes a
 * String is found, the returned value will be the String passed into
 * <code>stringToValue</code>.
 * <p>
 * Instances of <code>DefaultFormatter</code> can not be used in multiple
 * instances of <code>JFormattedTextField</code>. To obtain a copy of
 * an already configured <code>DefaultFormatter</code>, use the
 * <code>clone</code> method.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing.  As of 1.4, support for long term storage
 * of all JavaBeans&trade;
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @see javax.swing.JFormattedTextField.AbstractFormatter
 * @since 1.4
 */
public class DefaultFormatter extends JFormattedTextField.AbstractFormatter
    implements Cloneable, Serializable {

  /**
   * Indicates if the value being edited must match the mask.
   */
  private boolean allowsInvalid;

  /**
   * If true, editing mode is in overwrite (or strikethough).
   */
  private boolean overwriteMode;

  /**
   * If true, any time a valid edit happens commitEdit is invoked.
   */
  private boolean commitOnEdit;

  /**
   * Class used to create new instances.
   */
  private Class<?> valueClass;

  /**
   * NavigationFilter that forwards calls back to DefaultFormatter.
   */
  private NavigationFilter navigationFilter;

  /**
   * DocumentFilter that forwards calls back to DefaultFormatter.
   */
  private DocumentFilter documentFilter;

  /**
   * Used during replace to track the region to replace.
   */
  transient ReplaceHolder replaceHolder;


  /**
   * Creates a DefaultFormatter.
   */
  public DefaultFormatter() {
    overwriteMode = true;
    allowsInvalid = true;
  }

  /**
   * Installs the <code>DefaultFormatter</code> onto a particular
   * <code>JFormattedTextField</code>.
   * This will invoke <code>valueToString</code> to convert the
   * current value from the <code>JFormattedTextField</code> to
   * a String. This will then install the <code>Action</code>s from
   * <code>getActions</code>, the <code>DocumentFilter</code>
   * returned from <code>getDocumentFilter</code> and the
   * <code>NavigationFilter</code> returned from
   * <code>getNavigationFilter</code> onto the
   * <code>JFormattedTextField</code>.
   * <p>
   * Subclasses will typically only need to override this if they
   * wish to install additional listeners on the
   * <code>JFormattedTextField</code>.
   * <p>
   * If there is a <code>ParseException</code> in converting the
   * current value to a String, this will set the text to an empty
   * String, and mark the <code>JFormattedTextField</code> as being
   * in an invalid state.
   * <p>
   * While this is a public method, this is typically only useful
   * for subclassers of <code>JFormattedTextField</code>.
   * <code>JFormattedTextField</code> will invoke this method at
   * the appropriate times when the value changes, or its internal
   * state changes.
   *
   * @param ftf JFormattedTextField to format for, may be null indicating uninstall from current
   * JFormattedTextField.
   */
  public void install(JFormattedTextField ftf) {
    super.install(ftf);
    positionCursorAtInitialLocation();
  }

  /**
   * Sets when edits are published back to the
   * <code>JFormattedTextField</code>. If true, <code>commitEdit</code>
   * is invoked after every valid edit (any time the text is edited). On
   * the other hand, if this is false than the <code>DefaultFormatter</code>
   * does not publish edits back to the <code>JFormattedTextField</code>.
   * As such, the only time the value of the <code>JFormattedTextField</code>
   * will change is when <code>commitEdit</code> is invoked on
   * <code>JFormattedTextField</code>, typically when enter is pressed
   * or focus leaves the <code>JFormattedTextField</code>.
   *
   * @param commit Used to indicate when edits are committed back to the JTextComponent
   */
  public void setCommitsOnValidEdit(boolean commit) {
    commitOnEdit = commit;
  }

  /**
   * Returns when edits are published back to the
   * <code>JFormattedTextField</code>.
   *
   * @return true if edits are committed after every valid edit
   */
  public boolean getCommitsOnValidEdit() {
    return commitOnEdit;
  }

  /**
   * Configures the behavior when inserting characters. If
   * <code>overwriteMode</code> is true (the default), new characters
   * overwrite existing characters in the model.
   *
   * @param overwriteMode Indicates if overwrite or overstrike mode is used
   */
  public void setOverwriteMode(boolean overwriteMode) {
    this.overwriteMode = overwriteMode;
  }

  /**
   * Returns the behavior when inserting characters.
   *
   * @return true if newly inserted characters overwrite existing characters
   */
  public boolean getOverwriteMode() {
    return overwriteMode;
  }

  /**
   * Sets whether or not the value being edited is allowed to be invalid
   * for a length of time (that is, <code>stringToValue</code> throws
   * a <code>ParseException</code>).
   * It is often convenient to allow the user to temporarily input an
   * invalid value.
   *
   * @param allowsInvalid Used to indicate if the edited value must always be valid
   */
  public void setAllowsInvalid(boolean allowsInvalid) {
    this.allowsInvalid = allowsInvalid;
  }

  /**
   * Returns whether or not the value being edited is allowed to be invalid
   * for a length of time.
   *
   * @return false if the edited value must always be valid
   */
  public boolean getAllowsInvalid() {
    return allowsInvalid;
  }

  /**
   * Sets that class that is used to create new Objects. If the
   * passed in class does not have a single argument constructor that
   * takes a String, String values will be used.
   *
   * @param valueClass Class used to construct return value from stringToValue
   */
  public void setValueClass(Class<?> valueClass) {
    this.valueClass = valueClass;
  }

  /**
   * Returns that class that is used to create new Objects.
   *
   * @return Class used to construct return value from stringToValue
   */
  public Class<?> getValueClass() {
    return valueClass;
  }

  /**
   * Converts the passed in String into an instance of
   * <code>getValueClass</code> by way of the constructor that
   * takes a String argument. If <code>getValueClass</code>
   * returns null, the Class of the current value in the
   * <code>JFormattedTextField</code> will be used. If this is null, a
   * String will be returned. If the constructor throws an exception, a
   * <code>ParseException</code> will be thrown. If there is no single
   * argument String constructor, <code>string</code> will be returned.
   *
   * @param string String to convert
   * @return Object representation of text
   * @throws ParseException if there is an error in the conversion
   */
  public Object stringToValue(String string) throws ParseException {
    Class<?> vc = getValueClass();
    JFormattedTextField ftf = getFormattedTextField();

    if (vc == null && ftf != null) {
      Object value = ftf.getValue();

      if (value != null) {
        vc = value.getClass();
      }
    }
    if (vc != null) {
      Constructor cons;

      try {
        ReflectUtil.checkPackageAccess(vc);
        SwingUtilities2.checkAccess(vc.getModifiers());
        cons = vc.getConstructor(new Class[]{String.class});

      } catch (NoSuchMethodException nsme) {
        cons = null;
      }

      if (cons != null) {
        try {
          SwingUtilities2.checkAccess(cons.getModifiers());
          return cons.newInstance(new Object[]{string});
        } catch (Throwable ex) {
          throw new ParseException("Error creating instance", 0);
        }
      }
    }
    return string;
  }

  /**
   * Converts the passed in Object into a String by way of the
   * <code>toString</code> method.
   *
   * @param value Value to convert
   * @return String representation of value
   * @throws ParseException if there is an error in the conversion
   */
  public String valueToString(Object value) throws ParseException {
    if (value == null) {
      return "";
    }
    return value.toString();
  }

  /**
   * Returns the <code>DocumentFilter</code> used to restrict the characters
   * that can be input into the <code>JFormattedTextField</code>.
   *
   * @return DocumentFilter to restrict edits
   */
  protected DocumentFilter getDocumentFilter() {
    if (documentFilter == null) {
      documentFilter = new DefaultDocumentFilter();
    }
    return documentFilter;
  }

  /**
   * Returns the <code>NavigationFilter</code> used to restrict where the
   * cursor can be placed.
   *
   * @return NavigationFilter to restrict navigation
   */
  protected NavigationFilter getNavigationFilter() {
    if (navigationFilter == null) {
      navigationFilter = new DefaultNavigationFilter();
    }
    return navigationFilter;
  }

  /**
   * Creates a copy of the DefaultFormatter.
   *
   * @return copy of the DefaultFormatter
   */
  public Object clone() throws CloneNotSupportedException {
    DefaultFormatter formatter = (DefaultFormatter) super.clone();

    formatter.navigationFilter = null;
    formatter.documentFilter = null;
    formatter.replaceHolder = null;
    return formatter;
  }


  /**
   * Positions the cursor at the initial location.
   */
  void positionCursorAtInitialLocation() {
    JFormattedTextField ftf = getFormattedTextField();
    if (ftf != null) {
      ftf.setCaretPosition(getInitialVisualPosition());
    }
  }

  /**
   * Returns the initial location to position the cursor at. This forwards
   * the call to <code>getNextNavigatableChar</code>.
   */
  int getInitialVisualPosition() {
    return getNextNavigatableChar(0, 1);
  }

  /**
   * Subclasses should override this if they want cursor navigation
   * to skip certain characters. A return value of false indicates
   * the character at <code>offset</code> should be skipped when
   * navigating throught the field.
   */
  boolean isNavigatable(int offset) {
    return true;
  }

  /**
   * Returns true if the text in <code>text</code> can be inserted.  This
   * does not mean the text will ultimately be inserted, it is used if
   * text can trivially reject certain characters.
   */
  boolean isLegalInsertText(String text) {
    return true;
  }

  /**
   * Returns the next editable character starting at offset incrementing
   * the offset by <code>direction</code>.
   */
  private int getNextNavigatableChar(int offset, int direction) {
    int max = getFormattedTextField().getDocument().getLength();

    while (offset >= 0 && offset < max) {
      if (isNavigatable(offset)) {
        return offset;
      }
      offset += direction;
    }
    return offset;
  }

  /**
   * A convenience methods to return the result of deleting
   * <code>deleteLength</code> characters at <code>offset</code>
   * and inserting <code>replaceString</code> at <code>offset</code>
   * in the current text field.
   */
  String getReplaceString(int offset, int deleteLength,
      String replaceString) {
    String string = getFormattedTextField().getText();
    String result;

    result = string.substring(0, offset);
    if (replaceString != null) {
      result += replaceString;
    }
    if (offset + deleteLength < string.length()) {
      result += string.substring(offset + deleteLength);
    }
    return result;
  }

  /*
   * Returns true if the operation described by <code>rh</code> will
   * result in a legal edit.  This may set the <code>value</code>
   * field of <code>rh</code>.
   */
  boolean isValidEdit(ReplaceHolder rh) {
    if (!getAllowsInvalid()) {
      String newString = getReplaceString(rh.offset, rh.length, rh.text);

      try {
        rh.value = stringToValue(newString);

        return true;
      } catch (ParseException pe) {
        return false;
      }
    }
    return true;
  }

  /**
   * Invokes <code>commitEdit</code> on the JFormattedTextField.
   */
  void commitEdit() throws ParseException {
    JFormattedTextField ftf = getFormattedTextField();

    if (ftf != null) {
      ftf.commitEdit();
    }
  }

  /**
   * Pushes the value to the JFormattedTextField if the current value
   * is valid and invokes <code>setEditValid</code> based on the
   * validity of the value.
   */
  void updateValue() {
    updateValue(null);
  }

  /**
   * Pushes the <code>value</code> to the editor if we are to
   * commit on edits. If <code>value</code> is null, the current value
   * will be obtained from the text component.
   */
  void updateValue(Object value) {
    try {
      if (value == null) {
        String string = getFormattedTextField().getText();

        value = stringToValue(string);
      }

      if (getCommitsOnValidEdit()) {
        commitEdit();
      }
      setEditValid(true);
    } catch (ParseException pe) {
      setEditValid(false);
    }
  }

  /**
   * Returns the next cursor position from offset by incrementing
   * <code>direction</code>. This uses
   * <code>getNextNavigatableChar</code>
   * as well as constraining the location to the max position.
   */
  int getNextCursorPosition(int offset, int direction) {
    int newOffset = getNextNavigatableChar(offset, direction);
    int max = getFormattedTextField().getDocument().getLength();

    if (!getAllowsInvalid()) {
      if (direction == -1 && offset == newOffset) {
        // Case where hit backspace and only characters before
        // offset are fixed.
        newOffset = getNextNavigatableChar(newOffset, 1);
        if (newOffset >= max) {
          newOffset = offset;
        }
      } else if (direction == 1 && newOffset >= max) {
        // Don't go beyond last editable character.
        newOffset = getNextNavigatableChar(max - 1, -1);
        if (newOffset < max) {
          newOffset++;
        }
      }
    }
    return newOffset;
  }

  /**
   * Resets the cursor by using getNextCursorPosition.
   */
  void repositionCursor(int offset, int direction) {
    getFormattedTextField().getCaret().setDot(getNextCursorPosition
        (offset, direction));
  }


  /**
   * Finds the next navigable character.
   */
  int getNextVisualPositionFrom(JTextComponent text, int pos,
      Position.Bias bias, int direction,
      Position.Bias[] biasRet)
      throws BadLocationException {
    int value = text.getUI().getNextVisualPositionFrom(text, pos, bias,
        direction, biasRet);

    if (value == -1) {
      return -1;
    }
    if (!getAllowsInvalid() && (direction == SwingConstants.EAST ||
        direction == SwingConstants.WEST)) {
      int last = -1;

      while (!isNavigatable(value) && value != last) {
        last = value;
        value = text.getUI().getNextVisualPositionFrom(
            text, value, bias, direction, biasRet);
      }
      int max = getFormattedTextField().getDocument().getLength();
      if (last == value || value == max) {
        if (value == 0) {
          biasRet[0] = Position.Bias.Forward;
          value = getInitialVisualPosition();
        }
        if (value >= max && max > 0) {
          // Pending: should not assume forward!
          biasRet[0] = Position.Bias.Forward;
          value = getNextNavigatableChar(max - 1, -1) + 1;
        }
      }
    }
    return value;
  }

  /**
   * Returns true if the edit described by <code>rh</code> will result
   * in a legal value.
   */
  boolean canReplace(ReplaceHolder rh) {
    return isValidEdit(rh);
  }

  /**
   * DocumentFilter method, funnels into <code>replace</code>.
   */
  void replace(DocumentFilter.FilterBypass fb, int offset,
      int length, String text,
      AttributeSet attrs) throws BadLocationException {
    ReplaceHolder rh = getReplaceHolder(fb, offset, length, text, attrs);

    replace(rh);
  }

  /**
   * If the edit described by <code>rh</code> is legal, this will
   * return true, commit the edit (if necessary) and update the cursor
   * position.  This forwards to <code>canReplace</code> and
   * <code>isLegalInsertText</code> as necessary to determine if
   * the edit is in fact legal.
   * <p>
   * All of the DocumentFilter methods funnel into here, you should
   * generally only have to override this.
   */
  boolean replace(ReplaceHolder rh) throws BadLocationException {
    boolean valid = true;
    int direction = 1;

    if (rh.length > 0 && (rh.text == null || rh.text.length() == 0) &&
        (getFormattedTextField().getSelectionStart() != rh.offset ||
            rh.length > 1)) {
      direction = -1;
    }

    if (getOverwriteMode() && rh.text != null &&
        getFormattedTextField().getSelectedText() == null) {
      rh.length = Math.min(Math.max(rh.length, rh.text.length()),
          rh.fb.getDocument().getLength() - rh.offset);
    }
    if ((rh.text != null && !isLegalInsertText(rh.text)) ||
        !canReplace(rh) ||
        (rh.length == 0 && (rh.text == null || rh.text.length() == 0))) {
      valid = false;
    }
    if (valid) {
      int cursor = rh.cursorPosition;

      rh.fb.replace(rh.offset, rh.length, rh.text, rh.attrs);
      if (cursor == -1) {
        cursor = rh.offset;
        if (direction == 1 && rh.text != null) {
          cursor = rh.offset + rh.text.length();
        }
      }
      updateValue(rh.value);
      repositionCursor(cursor, direction);
      return true;
    } else {
      invalidEdit();
    }
    return false;
  }

  /**
   * NavigationFilter method, subclasses that wish finer control should
   * override this.
   */
  void setDot(NavigationFilter.FilterBypass fb, int dot, Position.Bias bias) {
    fb.setDot(dot, bias);
  }

  /**
   * NavigationFilter method, subclasses that wish finer control should
   * override this.
   */
  void moveDot(NavigationFilter.FilterBypass fb, int dot,
      Position.Bias bias) {
    fb.moveDot(dot, bias);
  }


  /**
   * Returns the ReplaceHolder to track the replace of the specified
   * text.
   */
  ReplaceHolder getReplaceHolder(DocumentFilter.FilterBypass fb, int offset,
      int length, String text,
      AttributeSet attrs) {
    if (replaceHolder == null) {
      replaceHolder = new ReplaceHolder();
    }
    replaceHolder.reset(fb, offset, length, text, attrs);
    return replaceHolder;
  }


  /**
   * ReplaceHolder is used to track where insert/remove/replace is
   * going to happen.
   */
  static class ReplaceHolder {

    /**
     * The FilterBypass that was passed to the DocumentFilter method.
     */
    DocumentFilter.FilterBypass fb;
    /**
     * Offset where the remove/insert is going to occur.
     */
    int offset;
    /**
     * Length of text to remove.
     */
    int length;
    /**
     * The text to insert, may be null.
     */
    String text;
    /**
     * AttributeSet to attach to text, may be null.
     */
    AttributeSet attrs;
    /**
     * The resulting value, this may never be set.
     */
    Object value;
    /**
     * Position the cursor should be adjusted from.  If this is -1
     * the cursor position will be adjusted based on the direction of
     * the replace (-1: offset, 1: offset + text.length()), otherwise
     * the cursor position is adusted from this position.
     */
    int cursorPosition;

    void reset(DocumentFilter.FilterBypass fb, int offset, int length,
        String text, AttributeSet attrs) {
      this.fb = fb;
      this.offset = offset;
      this.length = length;
      this.text = text;
      this.attrs = attrs;
      this.value = null;
      cursorPosition = -1;
    }
  }


  /**
   * NavigationFilter implementation that calls back to methods with
   * same name in DefaultFormatter.
   */
  private class DefaultNavigationFilter extends NavigationFilter
      implements Serializable {

    public void setDot(FilterBypass fb, int dot, Position.Bias bias) {
      JTextComponent tc = DefaultFormatter.this.getFormattedTextField();
      if (tc.composedTextExists()) {
        // bypass the filter
        fb.setDot(dot, bias);
      } else {
        DefaultFormatter.this.setDot(fb, dot, bias);
      }
    }

    public void moveDot(FilterBypass fb, int dot, Position.Bias bias) {
      JTextComponent tc = DefaultFormatter.this.getFormattedTextField();
      if (tc.composedTextExists()) {
        // bypass the filter
        fb.moveDot(dot, bias);
      } else {
        DefaultFormatter.this.moveDot(fb, dot, bias);
      }
    }

    public int getNextVisualPositionFrom(JTextComponent text, int pos,
        Position.Bias bias,
        int direction,
        Position.Bias[] biasRet)
        throws BadLocationException {
      if (text.composedTextExists()) {
        // forward the call to the UI directly
        return text.getUI().getNextVisualPositionFrom(
            text, pos, bias, direction, biasRet);
      } else {
        return DefaultFormatter.this.getNextVisualPositionFrom(
            text, pos, bias, direction, biasRet);
      }
    }
  }


  /**
   * DocumentFilter implementation that calls back to the replace
   * method of DefaultFormatter.
   */
  private class DefaultDocumentFilter extends DocumentFilter implements
      Serializable {

    public void remove(FilterBypass fb, int offset, int length) throws
        BadLocationException {
      JTextComponent tc = DefaultFormatter.this.getFormattedTextField();
      if (tc.composedTextExists()) {
        // bypass the filter
        fb.remove(offset, length);
      } else {
        DefaultFormatter.this.replace(fb, offset, length, null, null);
      }
    }

    public void insertString(FilterBypass fb, int offset,
        String string, AttributeSet attr) throws
        BadLocationException {
      JTextComponent tc = DefaultFormatter.this.getFormattedTextField();
      if (tc.composedTextExists() ||
          Utilities.isComposedTextAttributeDefined(attr)) {
        // bypass the filter
        fb.insertString(offset, string, attr);
      } else {
        DefaultFormatter.this.replace(fb, offset, 0, string, attr);
      }
    }

    public void replace(FilterBypass fb, int offset, int length,
        String text, AttributeSet attr) throws
        BadLocationException {
      JTextComponent tc = DefaultFormatter.this.getFormattedTextField();
      if (tc.composedTextExists() ||
          Utilities.isComposedTextAttributeDefined(attr)) {
        // bypass the filter
        fb.replace(offset, length, text, attr);
      } else {
        DefaultFormatter.this.replace(fb, offset, length, text, attr);
      }
    }
  }
}
